home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / fspdev / fspdevInt.h < prev    next >
C/C++ Source or Header  |  1991-06-26  |  17KB  |  422 lines
  1. /*
  2.  * fspdevInt.h --
  3.  *
  4.  *    Declarations for pseudo-devices and pseudo-filesystems.
  5.  *
  6.  *    A pseudo-device is a file that acts as a communication channel
  7.  *    between a user-level server process (hereafter called the "server"),
  8.  *    and one or more client processes (hereafter called the "clients").
  9.  *    Regular filesystem system calls (Fs_Read, Fs_Write, Fs_IOControl,
  10.  *    Fs_Close) by a client process are forwarded to the server using
  11.  *    a request-response procotol.  The server process can implement any
  12.  *    sort of sementics for the file operations it wants to. The general
  13.  *    format of Fs_IOControl, in particular, lets the server implement
  14.  *    any remote procedure call it cares to define.
  15.  *
  16.  *    A pseudo-filesystem is a whole sub-tree of the filesystem that
  17.  *    is controlled by a user-level server process.  The basic request
  18.  *    response protocol is still used for communication.  In addition to
  19.  *    file access operations, file naming operations are handled by
  20.  *    a pseudo-filesystem server.  The pseudo-filesystem server can
  21.  *    establish pseudo-device like connections for each pseudo-file
  22.  *    that is opened, or it can open regular files and connect its
  23.  *    clients to those files instead.
  24.  *
  25.  *    The user include file <dev/pdev.h> defines the request-response
  26.  *    protocol as viewed by the user-level server process.
  27.  *
  28.  *      The handle definitions have been moved to fspdev.h   JMS
  29.  *
  30.  * Copyright 1987 Regents of the University of California
  31.  * All rights reserved.
  32.  *
  33.  *
  34.  * $Header: /sprite/src/kernel/fspdev/RCS/fspdevInt.h,v 9.4 91/06/26 01:06:44 mottsmth Exp $ SPRITE (Berkeley)
  35.  */
  36.  
  37. #ifndef _FSPDEVINT
  38. #define _FSPDEVINT
  39.  
  40. #include <trace.h>
  41. #include <dev/pdev.h>
  42. #include <dev/pfs.h>
  43. #include <fsioLock.h>
  44. #include <fspdev.h>
  45.  
  46. #include <stdio.h>
  47.  
  48. /*
  49.  * Because there are corresponding control handles on the file server,
  50.  * which records which host has the pdev server, and on the pdev server
  51.  * itself, we need to be able to reopen the control handle on the
  52.  * file server after it reboots.
  53.  */
  54. typedef struct FspdevControlReopenParams {
  55.     Fs_FileID    fileID;        /* FileID of the control handle */
  56.     int        serverID;    /* ServerID recorded in control handle.
  57.                  * This may be NIL if the server closes
  58.                  * while the file server is down. */
  59.     int        seed;        /* Used to create unique pseudo-stream fileIDs*/
  60. } FspdevControlReopenParams;
  61.  
  62. /*
  63.  * The following control messages are passed internally from the
  64.  * ServerStreamCreate routine to the FspdevControlRead routine.
  65.  * They contain a streamPtr for a new server stream
  66.  * that gets converted to a user-level streamID in FspdevControlRead.
  67.  */
  68.  
  69. typedef struct FspdevNotify {
  70.     List_Links links;
  71.     Fs_Stream *streamPtr;
  72. } FspdevNotify;
  73.  
  74. /*
  75.  * The following types and macros are used to take pdev traces.
  76.  */
  77. typedef enum { PDEVT_NIL, PDEVT_SRV_OPEN, PDEVT_CLT_OPEN, PDEVT_READ_AHEAD,
  78.            PDEVT_SRV_CLOSE, PDEVT_CLT_CLOSE, PDEVT_READ_WAIT, 
  79.            PDEVT_WAKEUP, PDEVT_REQUEST, PDEVT_REPLY,
  80.            PDEVT_SRV_READ, PDEVT_SRV_READ_WAIT, PDEVT_SRV_WRITE,
  81.            PDEVT_SRV_SELECT, PDEVT_CNTL_READ, PDEVT_WAIT_LIST,
  82.            PDEVT_SELECT} FspdevTraceRecType ;
  83.  
  84. typedef struct FspdevTraceRecord {
  85.     int index;
  86.     Fs_FileID fileID;
  87.     union {
  88.     Pdev_RequestHdr    requestHdr;
  89.     Pdev_Reply    reply;
  90.     int        selectBits;
  91.     struct WaitTrace {
  92.         int        selectBits;
  93.         Proc_PID    procID;
  94.     } wait;
  95.     Fsio_UseCounts    use;
  96.     } un;
  97. } FspdevTraceRecord;
  98.  
  99. #ifndef CLEAN
  100.  
  101. #define PDEV_TRACE(fileIDPtr, event) \
  102.     if (fspdevTracing) { \
  103.     FspdevTraceRecord rec; \
  104.     rec.index = ++fspdevTraceIndex; \
  105.     rec.fileID = *(fileIDPtr); \
  106.     Trace_Insert(fspdevTraceHdrPtr, event, (ClientData)&rec);    \
  107.     }
  108.  
  109. #define PDEV_REQUEST(fileIDPtr, requestHdrPtr) \
  110.     if (fspdevTracing) {                            \
  111.     FspdevTraceRecord rec; \
  112.     rec.index = ++fspdevTraceIndex; \
  113.     rec.fileID = *(fileIDPtr); \
  114.     rec.un.requestHdr = *(requestHdrPtr); \
  115.     Trace_Insert(fspdevTraceHdrPtr, PDEVT_REQUEST, (ClientData)&rec);\
  116.     }
  117.  
  118. #define PDEV_REPLY(fileIDPtr, replyPtr) \
  119.     if (fspdevTracing) {                            \
  120.     FspdevTraceRecord rec; \
  121.     rec.index = ++fspdevTraceIndex; \
  122.     rec.fileID = *(fileIDPtr); \
  123.     rec.un.reply = *(replyPtr); \
  124.     Trace_Insert(fspdevTraceHdrPtr, PDEVT_REPLY, (ClientData)&rec);\
  125.     }
  126.  
  127. #define PDEV_TSELECT(fileIDPtr, read, write, except) \
  128.     if (fspdevTracing) {                            \
  129.     FspdevTraceRecord rec; \
  130.     rec.index = ++fspdevTraceIndex; \
  131.     rec.fileID = *(fileIDPtr); \
  132.     rec.un.selectBits = 0; \
  133.     if (read) { rec.un.selectBits |= FS_READABLE; } \
  134.     if (write) { rec.un.selectBits |= FS_WRITABLE; } \
  135.     if (except) { rec.un.selectBits |= FS_EXCEPTION; } \
  136.     Trace_Insert(fspdevTraceHdrPtr, PDEVT_SELECT, (ClientData)&rec);\
  137.     }
  138.  
  139. #define PDEV_WAKEUP(fileIDPtr, zprocID, zselectBits) \
  140.     if (fspdevTracing) {                            \
  141.     FspdevTraceRecord rec; \
  142.     rec.index = ++fspdevTraceIndex; \
  143.     rec.fileID = *(fileIDPtr); \
  144.     rec.un.wait.selectBits = zselectBits; \
  145.     rec.un.wait.procID = zprocID; \
  146.     Trace_Insert(fspdevTraceHdrPtr, PDEVT_WAKEUP, (ClientData)&rec);\
  147.     }
  148. #define DBG_PRINT(fmt)    if (fspdev_Debug) { printf fmt ; }
  149.  
  150. #define PDEV_REQUEST_PRINT(fileIDPtr, requestHdrPtr) \
  151.     switch(requestHdrPtr->operation) {    \
  152.     case PDEV_OPEN:    \
  153.         DBG_PRINT( ("Pdev %d,%d: Open  ", (fileIDPtr)->major, \
  154.                          (fileIDPtr)->minor) ); \
  155.         break;    \
  156.     case PDEV_READ:    \
  157.         DBG_PRINT( ("Pdev %d,%d: Read  ", (fileIDPtr)->major, \
  158.                          (fileIDPtr)->minor) ); \
  159.         break;    \
  160.     case PDEV_WRITE:    \
  161.         DBG_PRINT( ("Pdev %d,%d: Write ", (fileIDPtr)->major, \
  162.                          (fileIDPtr)->minor) ); \
  163.         break;    \
  164.     case PDEV_CLOSE:    \
  165.         DBG_PRINT( ("Pdev %d,%d: Close ", (fileIDPtr)->major, \
  166.                          (fileIDPtr)->minor) ); \
  167.         break;    \
  168.     case PDEV_IOCTL:    \
  169.         DBG_PRINT( ("Pdev %d,%d: Ioctl ", (fileIDPtr)->major, \
  170.                          (fileIDPtr)->minor) ); \
  171.         break;    \
  172.     default:    \
  173.         DBG_PRINT( ("Pdev %d,%d: ?!?   ", (fileIDPtr)->major, \
  174.                          (fileIDPtr)->minor) ); \
  175.         break;    \
  176.     }
  177. #else
  178. /*
  179.  * Compiling with -DCLEAN will zap the if statements and procedure
  180.  * calls defined by the above macros
  181.  */
  182. #define DBG_PRINT(fmt)
  183.  
  184. #define PDEV_TRACE(fileIDPtr, event)
  185. #define PDEV_REQUEST(fileIDPtr, requestHdrPtr)
  186. #define PDEV_REPLY(fileIDPtr, replyPtr)
  187. #define PDEV_TSELECT(fileIDPtr, read, write, except)
  188. #define PDEV_WAKEUP(fileIDPtr, waitInfoPtr, selectBits)
  189.  
  190. #endif not CLEAN
  191.  
  192. /*
  193.  * Internal Pdev routines
  194.  */
  195. extern ReturnStatus FspdevSignalOwner _ARGS_((
  196.         Fspdev_ControlIOHandle *ctrlHandlePtr, Fs_IOCParam *ioctlPtr));
  197. extern Fspdev_ClientIOHandle *FspdevConnect _ARGS_((
  198.         Fspdev_ControlIOHandle *ctrlHandlePtr, Fs_FileID *ioFileIDPtr,
  199.         int clientID, Boolean naming));
  200.  
  201. /*
  202.  * Definitions for a trace of the request-response protocol.
  203.  */
  204. extern Trace_Header fspdevTraceHdr;
  205. extern Trace_Header *fspdevTraceHdrPtr;
  206. extern int fspdevTraceLength;
  207. extern Boolean fspdevTracing;
  208. extern int fspdevMaxTraceDataSize;
  209. extern int fspdevTraceIndex;
  210. /*
  211.  * File server open-time routines.
  212.  */
  213. extern ReturnStatus FspdevNameOpen _ARGS_((Fsio_FileIOHandle *handlePtr,
  214.         Fs_OpenArgs *openArgsPtr, Fs_OpenResults *openResultsPtr));
  215. extern ReturnStatus FspdevRmtLinkNameOpen _ARGS_((Fsio_FileIOHandle *handlePtr,
  216.         Fs_OpenArgs *openArgsPtr, Fs_OpenResults *openResultsPtr));
  217. /*
  218.  * Control Stream routines.
  219.  */
  220. extern Fspdev_ControlIOHandle *FspdevControlHandleInit _ARGS_((
  221.         Fs_FileID *fileIDPtr, char *name));
  222. extern ReturnStatus FspdevControlIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  223.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  224.         Fs_HandleHeader **ioHandlePtrPtr));
  225. extern ReturnStatus FspdevControlSelect _ARGS_((Fs_HandleHeader *hdrPtr, 
  226.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr, 
  227.         int *exceptPtr));
  228. extern ReturnStatus FspdevControlRead _ARGS_((Fs_Stream *streamPtr, 
  229.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr, 
  230.         Fs_IOReply *replyPtr));
  231. extern ReturnStatus FspdevControlIOControl _ARGS_((Fs_Stream *streamPtr, 
  232.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  233. extern ReturnStatus FspdevControlGetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  234.         int clientID, Fs_Attributes *attrPtr));
  235. extern ReturnStatus FspdevControlSetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  236.         Fs_Attributes *attrPtr, int flags));
  237. extern Fs_HandleHeader *FspdevControlVerify _ARGS_((Fs_FileID *fileIDPtr, 
  238.         int pdevServerHostID, int *domainTypePtr));
  239. extern ReturnStatus FspdevControlReopen _ARGS_((Fs_HandleHeader *hdrPtr,
  240.         int clientID, ClientData inData, int *outSizePtr, 
  241.         ClientData *outDataPtr));
  242. #ifdef SOSP91
  243. extern ReturnStatus FspdevControlClose _ARGS_((Fs_Stream *streamPtr, 
  244.         int clientID, Proc_PID procID, int flags, int size,
  245.         ClientData data, int *offsetPtr, int *rwFlagsPtr));
  246. #else
  247. extern ReturnStatus FspdevControlClose _ARGS_((Fs_Stream *streamPtr, 
  248.         int clientID, Proc_PID procID, int flags, int size,
  249.         ClientData data));
  250. #endif
  251. extern void FspdevControlClientKill _ARGS_((Fs_HandleHeader *hdrPtr,
  252.         int clientID));
  253. extern Boolean FspdevControlScavenge _ARGS_((Fs_HandleHeader *hdrPtr));
  254. /*
  255.  * Pfs Control Stream routines.
  256.  */
  257. extern ReturnStatus FspdevPfsIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  258.         int *flagsPtr, int clientID, ClientData streamData,
  259.         char *name, Fs_HandleHeader **ioHandlePtrPtr));
  260. /*
  261.  * Server stream routines.
  262.  */
  263. extern ReturnStatus FspdevServerStreamSelect _ARGS_((Fs_HandleHeader *hdrPtr,
  264.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr, 
  265.         int *exceptPtr));
  266. extern ReturnStatus FspdevServerStreamRead _ARGS_((Fs_Stream *streamPtr, 
  267.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr,
  268.         Fs_IOReply *replyPtr));
  269. extern ReturnStatus FspdevServerStreamIOControl _ARGS_((Fs_Stream *streamPtr, 
  270.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  271. #ifdef SOSP91
  272. extern ReturnStatus FspdevServerStreamClose _ARGS_((Fs_Stream *streamPtr, 
  273.         int clientID, Proc_PID procID, int flags, int size, 
  274.         ClientData data, int *offsetPtr, int *rwFlagsPtr));
  275. #else
  276. extern ReturnStatus FspdevServerStreamClose _ARGS_((Fs_Stream *streamPtr, 
  277.         int clientID, Proc_PID procID, int flags, int size, 
  278.         ClientData data));
  279. #endif
  280. /*
  281.  * Pseudo-device (client-side) streams
  282.  */
  283. extern ReturnStatus FspdevPseudoStreamIoOpen _ARGS_(( Fs_FileID *ioFileIDPtr,
  284.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  285.         Fs_HandleHeader **ioHandlePtrPtr));
  286. extern ReturnStatus FspdevPseudoStreamOpen _ARGS_((
  287.         Fspdev_ServerIOHandle *pdevHandlePtr, int flags, int clientID, 
  288.         Proc_PID procID, int userID));
  289. extern ReturnStatus FspdevPseudoStreamRead _ARGS_((Fs_Stream *streamPtr, 
  290.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr, 
  291.         Fs_IOReply *replyPtr));
  292. extern ReturnStatus FspdevPseudoStreamWrite _ARGS_((Fs_Stream *streamPtr, 
  293.         Fs_IOParam *writePtr, Sync_RemoteWaiter *waitPtr, 
  294.         Fs_IOReply *replyPtr));
  295. extern ReturnStatus FspdevPseudoStreamIOControl _ARGS_((Fs_Stream *streamPtr, 
  296.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  297. extern ReturnStatus FspdevPseudoStreamSelect _ARGS_((Fs_HandleHeader *hdrPtr,
  298.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr,
  299.         int *exceptPtr));
  300. extern ReturnStatus FspdevPseudoStreamGetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  301.         int clientID,   Fs_Attributes *attrPtr));
  302. extern ReturnStatus FspdevPseudoStreamSetIOAttr _ARGS_((Fs_FileID *fileIDPtr,
  303.         Fs_Attributes *attrPtr, int flags));
  304. extern ReturnStatus FspdevPseudoStreamMigClose _ARGS_((Fs_HandleHeader *hdrPtr,
  305.         int flags));
  306. extern ReturnStatus FspdevPseudoStreamMigrate _ARGS_((Fsio_MigInfo *migInfoPtr,
  307.         int dstClientID, int *flagsPtr, int *offsetPtr, int *sizePtr,
  308.         Address *dataPtr));
  309. extern ReturnStatus FspdevPseudoStreamMigOpen _ARGS_((Fsio_MigInfo *migInfoPtr,
  310.         int size, ClientData data, Fs_HandleHeader **hdrPtrPtr));
  311. #ifdef SOSP91
  312. extern ReturnStatus FspdevPseudoStreamClose _ARGS_((Fs_Stream *streamPtr, 
  313.         int clientID, Proc_PID procID, int flags, int size,
  314.         ClientData data, int *offsetPtr, int *rwFlagsPtr));
  315. #else
  316. extern ReturnStatus FspdevPseudoStreamClose _ARGS_((Fs_Stream *streamPtr, 
  317.         int clientID, Proc_PID procID, int flags, int size,
  318.         ClientData data));
  319. #endif
  320. extern void FspdevPseudoStreamCloseInt _ARGS_((    
  321.         Fspdev_ServerIOHandle *pdevHandlePtr));
  322.  
  323. extern Fspdev_ServerIOHandle *FspdevServerStreamCreate _ARGS_((
  324.         Fs_FileID *ioFileIDPtr, char *name, Boolean naming));
  325.  
  326. /*
  327.  * Remote pseudo-device streams
  328.  */
  329. extern ReturnStatus FspdevRmtPseudoStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  330.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  331.         Fs_HandleHeader **ioHandlePtrPtr));
  332. extern Fs_HandleHeader *FspdevRmtPseudoStreamVerify _ARGS_((
  333.         Fs_FileID *fileIDPtr, int clientID, int *domainTypePtr));
  334. extern ReturnStatus FspdevRmtPseudoStreamMigrate _ARGS_((
  335.         Fsio_MigInfo *migInfoPtr, int dstClientID, int *flagsPtr,
  336.         int *offsetPtr, int *sizePtr, Address *dataPtr));
  337. /*
  338.  * Local and remote pseudo-device streams to pseudo-file-systems
  339.  */
  340. extern ReturnStatus FspdevPfsStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  341.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  342.         Fs_HandleHeader **ioHandlePtrPtr));
  343. extern ReturnStatus FspdevRmtPfsStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  344.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  345.         Fs_HandleHeader **ioHandlePtrPtr));
  346. /*
  347.  * Naming Stream routines.
  348.  */
  349. extern ReturnStatus FspdevPfsExport _ARGS_((Fs_HandleHeader *hdrPtr,
  350.         int clientID, register Fs_FileID *ioFileIDPtr, 
  351.         int *dataSizePtr, ClientData *clientDataPtr));
  352. extern ReturnStatus FspdevPfsNamingIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  353.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  354.         Fs_HandleHeader **ioHandlePtrPtr));
  355. /*
  356.  * Pseudo-file-system naming routines.
  357.  */
  358. extern ReturnStatus FspdevPfsOpen _ARGS_((Fs_HandleHeader *prefixHandle,
  359.         char *relativeName, Address argsPtr, Address resultsPtr, 
  360.         Fs_RedirectInfo **newNameInfoPtrPtr));
  361. extern ReturnStatus FspdevPfsGetAttrPath _ARGS_((Fs_HandleHeader *prefixHandle,
  362.         char *relativeName, Address argsPtr, Address resultsPtr, 
  363.         Fs_RedirectInfo **newNameInfoPtrPtr));
  364. extern ReturnStatus FspdevPfsSetAttrPath _ARGS_((Fs_HandleHeader *prefixHandle,
  365.         char *relativeName, Address argsPtr, Address resultsPtr,
  366.         Fs_RedirectInfo **newNameInfoPtrPtr));
  367. extern ReturnStatus FspdevPfsMakeDir _ARGS_((Fs_HandleHeader *prefixHandle,
  368.         char *relativeName, Address argsPtr, Address resultsPtr,
  369.         Fs_RedirectInfo **newNameInfoPtrPtr));
  370. extern ReturnStatus FspdevPfsMakeDevice _ARGS_((Fs_HandleHeader *prefixHandle, 
  371.         char *relativeName, Address argsPtr, Address resultsPtr,
  372.         Fs_RedirectInfo **newNameInfoPtrPtr));
  373. extern ReturnStatus FspdevPfsRemove _ARGS_((Fs_HandleHeader *prefixHandle,
  374.         char *relativeName, Address argsPtr, Address resultsPtr,
  375.         Fs_RedirectInfo **newNameInfoPtrPtr));
  376. extern ReturnStatus FspdevPfsRemoveDir _ARGS_((Fs_HandleHeader *prefixHandle,
  377.         char *relativeName, Address argsPtr, Address resultsPtr, 
  378.         Fs_RedirectInfo **newNameInfoPtrPtr));
  379. extern ReturnStatus FspdevPfsRename _ARGS_((Fs_HandleHeader *prefixHandle1,
  380.         char *relativeName1, Fs_HandleHeader *prefixHandle2,
  381.         char *relativeName2, Fs_LookupArgs *lookupArgsPtr, 
  382.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  383. extern ReturnStatus FspdevPfsHardLink _ARGS_((Fs_HandleHeader *prefixHandle1,
  384.         char *relativeName1, Fs_HandleHeader *prefixHandle2,
  385.         char *relativeName2, Fs_LookupArgs *lookupArgsPtr, 
  386.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  387. extern ReturnStatus FspdevPfs2Path _ARGS_((Pdev_Op operation, 
  388.         Fs_HandleHeader *prefixHandle1, char *relativeName1, 
  389.         Fs_HandleHeader *prefixHandle2, char *relativeName2,
  390.         Fs_LookupArgs *lookupArgsPtr, 
  391.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  392. extern ReturnStatus FspdevPseudoStream2Path _ARGS_((
  393.         Fspdev_ServerIOHandle *pdevHandlePtr, Pfs_Request *requestPtr,
  394.         Fs_2PathData *dataPtr, Boolean *name1ErrorPtr, 
  395.         Fs_RedirectInfo **newNameInfoPtrPtr));
  396.  
  397. extern ReturnStatus FspdevPseudoStreamLookup _ARGS_((
  398.         Fspdev_ServerIOHandle *pdevHandlePtr, Pfs_Request *requestPtr,
  399.         int argSize, Address argsPtr, int *resultsSizePtr, 
  400.         Address resultsPtr, Fs_RedirectInfo **newNameInfoPtrPtr));
  401.  
  402. /*
  403.  * Pseudo-file-system routines given an open file.
  404.  */
  405. extern ReturnStatus FspdevPseudoGetAttr _ARGS_((Fs_FileID *fileIDPtr, 
  406.         int clientID, Fs_Attributes *attrPtr));
  407. extern ReturnStatus FspdevPseudoSetAttr _ARGS_((Fs_FileID *fileIDPtr, 
  408.         Fs_Attributes *attrPtr, Fs_UserIDs *idPtr, int flags));
  409.  
  410. extern Boolean FspdevPdevServerOK _ARGS_((Fspdev_ServerIOHandle *pdevHandlePtr));
  411.  
  412. extern ReturnStatus FspdevPassStream _ARGS_((Fs_FileID *ioFileIDPtr,
  413.         int *flagsPtr, int clientID, ClientData streamData, 
  414.         char *name, Fs_HandleHeader **ioHandlePtrPtr));
  415.  
  416.  
  417. extern int FspdevPfsOpenConnection _ARGS_((
  418.         Fspdev_ServerIOHandle *namingPdevHandlePtr, 
  419.         Fs_FileID *srvrFileIDPtr, Fs_OpenResults *openResultsPtr));
  420.  
  421. #endif _FSPDEVINT
  422.